PC for Alla 2005 May/PC för Alla 0505.iso/fullversioner/realsoft3d/data1.cab/Scripting/scripts/js/real/objects/r3nurbs.js

JavaScript | 2005-04-04 | 18.2 KB | 618 lines

// JavaScript wrapper for r3nurbs.h
// Auto generated file, do not modify by hand
// Copyright ⌐ 2004, Realsoft Graphics Oy

var R3_NURBS_H = 1;
include("real/objects/r3prim.js")
include("oops/r3vector.js")
include("real/3d/r3nulib.js")


var R3CLID_NURBS = 130;




// Description: Concatenates given curves to itself. If the 'p1' is TRUE, fixed order concatenation is
//      applied. if 'p1' is false, the order is is determined from the distances between the
//      end points of the curves. Note: this method ignores all 'closed' curves.
// Returns: Boolean, TRUE if concatenation succeeded.
// p1: Boolean, TRUE to autoconcatenate, FALSE to fixed order
// p3: Object[], null terminated array of objects to be concatenated

R3NUM_CONCATENATE = 130000;

function mR3NUM_CONCATENATE(p1, p3) {
  return   DoA2(this.r3obj, 130000, p1, R3TID_BOOLEAN, 0, p3, R3TID_OBJECT, R3TNF_ARRAY);
}

// Description: Make the curve 'sharp' at given parameter value by increasing the multiplicity of the
//      given knot value. The shape of the curve remains unchanged.

R3NUM_SHARPEN = 130001;

function mR3NUM_SHARPEN() {
  DoA(this.r3obj, 130001, 0, R3TID_INTEGER, 0);
}

// Description: Break the curve selected point(s).

R3NUM_BREAK = 130002;

function mR3NUM_BREAK() {
  DoA(this.r3obj, 130002, 0, R3TID_INTEGER, 0);
}

// Description: Insert new knot to a curve. The shape of the curve is not changed.
// Returns: Boolean, true if knot was succesfully inserted. FALSE if failed.
// p1: Boolean, if true, parameter value 'p3' is local, if FALSE, 'p3' is global
// p3: Number, parameter value

R3NUM_INSERTKNOT = 130003;

function mR3NUM_INSERTKNOT(p1, p3) {
  return   DoA2(this.r3obj, 130003, p1, R3TID_BOOLEAN, 0, p3, R3TID_FLOAT, 0);
}

// Description: Convert the nurbs to bezier curve without changing the shape.

R3NUM_TOBEZIER = 130004;

function mR3NUM_TOBEZIER() {
  DoA(this.r3obj, 130004, 0, R3TID_INTEGER, 0);
}

// Description: Elevate the degree of the curve. The shape of the curve remains unchanged.
// Returns: Boolean, true if succeeded.

R3NUM_ELEVATEDEGREE = 130005;

function mR3NUM_ELEVATEDEGREE() {
  return   DoA(this.r3obj, 130005, 0, R3TID_INTEGER, 0);
}

// Description: Cut off the head of the curve at the given parameter value.
// Returns: Boolean, true if succeeded.

R3NUM_CUTHEAD = 130006;

function mR3NUM_CUTHEAD() {
  return   DoA(this.r3obj, 130006, 0, R3TID_INTEGER, 0);
}

// Description: Cut off the tail of the curve at the given parameter value.
// Returns: Boolean, true if succeeded.

R3NUM_CUTTAIL = 130007;

function mR3NUM_CUTTAIL() {
  return   DoA(this.r3obj, 130007, 0, R3TID_INTEGER, 0);
}

// Description: Changes the direction of the curve.
// Returns: Boolean, true if succeeded

R3NUM_SWAPDIRECTION = 130008;

function mR3NUM_SWAPDIRECTION() {
  return   DoA(this.r3obj, 130008, 0, R3TID_INTEGER, 0);
}

// Description: Tranlate the weights of the selected control points.
// p1: Boolean, if true, p3 translates the current weight. Otherwise p3 is taken as new absolute
//      weight for the selected points.
// p3: Number, abs/rel weight

R3NUM_CHANGEWEIGHTS = 130009;

function mR3NUM_CHANGEWEIGHTS(p1, p3) {
  DoA2(this.r3obj, 130009, p1, R3TID_BOOLEAN, 0, p3, R3TID_FLOAT, 0);
}

// Description: Raise/drop the order of the curve. The shape of the curve doesn't remain the
//      same.
// Returns: Boolean, true of succeeded. FALSE if the curve order cannot be changed
// p3: Integer, defines how much the curve order is increased/decreased. Positive values increase the order. Negative
//      decrease.

R3NUM_CHANGEORDER = 130010;

function mR3NUM_CHANGEORDER(p3) {
  return   DoA(this.r3obj, 130010, p3, R3TID_INTEGER, 0);
}

// Description: Inserts knots in the given array.
// Returns: Boolean, true if succeeded.
// p1: Integer, number of knots
// p3: Number, knots to be inserted.

R3NUM_INSERTKNOTARRAY = 130011;

function mR3NUM_INSERTKNOTARRAY(p1, p3) {
  return   DoA2(this.r3obj, 130011, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Add two extra points to the curve (if curve is open) and run inversion
//      so that the curve passes through its all original control points.

R3NUM_INTERPOLATE = 130012;

function mR3NUM_INTERPOLATE() {
  DoA(this.r3obj, 130012, 0, R3TID_INTEGER, 0);
}

// Description: Make the order, knot sequence and point count of the give nurbs curves the
//      same. The operation doesn't change the shape of the curves. If all curves are closed,
//      resulting curve is closed, if one of the curves is open, all resulting curves are
//      opened.
// Returns: Boolean, true if succeeded
// p3: Object[], null terminated array of curves

R3NUCM_UNIFY = 130013;

function mR3NUCM_UNIFY(p3) {
  return   DoA(this.r3obj, 130013, p3, R3TID_OBJECT, R3TNF_ARRAY);
}

// Description: Open the given closed curve. The shape of the curve is not changed.
// Returns: Boolean, True if curve was succesfully opened.
// p3: Boolean, if true, resulting curve ends have multiplicity

R3NUM_OPEN = 130014;

function mR3NUM_OPEN(p3) {
  return   DoA(this.r3obj, 130014, p3, R3TID_BOOLEAN, 0);
}

// Description: Set start point (u = 0) for closed curve (translate parameter space 'p3' ->
//      0.0). The shape of the curve is not changed.
// Returns: Boolean, true if succeeded.

R3NUM_SETSTART = 130015;

function mR3NUM_SETSTART() {
  return   DoA(this.r3obj, 130015, 0, R3TID_INTEGER, 0);
}

// Description: Create parallel curve
// Returns: Object, parallel curve
// p1: r3Vect, normal
// p3: Number, displacement. Positive value creates bigger parallel curve, negative shrunk curve.

R3NUM_PARALLELCURVE = 130016;

function mR3NUM_PARALLELCURVE(p1, p3) {
  return R3ToJS(  DoA2(this.r3obj, 130016, p1, R3TID_VECTOR, 0, p3, R3TID_FLOAT, 0));
}

// Description: Prepare curve for shrink operation.
// Returns: Boolean, true if succeeded
// p2: r3Vect, normal
// p3: r3List, list for prepared curves

R3NUM_ADDTOSHRINK = 130017;

function mR3NUM_ADDTOSHRINK(p2, p3) {
  return   DoA3(this.r3obj, 130017, 0, R3TID_INTEGER, 0, p2, R3TID_VECTOR, 0, p3, R3TID_LIST, 0);
}

// Description: Class message: Prepare all curves for shrink operation
// Returns: Boolean, true if succeeded
// p1: r3List, curves to be shrunk
// p3: Boolean, bevel out

R3NUCM_PREPARESHRINK = 130018;

function mR3NUCM_PREPARESHRINK(p1, p3) {
  return   DoA2(this.r3obj, 130018, p1, R3TID_LIST, 0, p3, R3TID_BOOLEAN, 0);
}

// Description: Class message: Shrink curves
// Returns: Boolean, true if succeeded
// p1: r3List, curves to be shrunk
// p3: Number, radius

R3NUCM_SHRINK = 130019;

function mR3NUCM_SHRINK(p1, p3) {
  return   DoA2(this.r3obj, 130019, p1, R3TID_LIST, 0, p3, R3TID_FLOAT, 0);
}

// Description: Free shrunk curves
// p3: r3List, curve node list

R3NUCM_FREESHRINK = 130020;

function mR3NUCM_FREESHRINK(p3) {
  DoA(this.r3obj, 130020, p3, R3TID_LIST, 0);
}

// Description: Insert control point to a curve
// Returns: Boolean, true if succeeded
// p1: Integer, index of the new point
// p3: r3Vect4, value for the new point

R3NUM_INSERTCTRLPOINT = 130021;

function mR3NUM_INSERTCTRLPOINT(p1, p3) {
  return   DoA2(this.r3obj, 130021, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR4, 0);
}

// Description: Set control point
// Returns: Boolean, true if succeeded
// p1: Integer, index of the point to be set
// p3: r3Vect, new value for the point

R3NUM_SETPOINT4 = 130023;

function mR3NUM_SETPOINT4(p1, p3) {
  return   DoA2(this.r3obj, 130023, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR, 0);
}

// Description: Fetch control point
// Returns: Boolean, true if succeeded
// p1: r3Vect, value for the point
// p3: Integer, index of the point to be fetched

R3NUM_GETPOINT4 = 130024;

function mR3NUM_GETPOINT4(p1, p3) {
  return   DoA2(this.r3obj, 130024, p1, R3TID_VECTOR, 0, p3, R3TID_INTEGER, 0);
}

// Description: Set knot value by index
// Returns: Boolean, true if succeeded
// p1: Integer, index of the point to be fetched
// p3: Number, buffer

R3NUM_SETKNOT = 130025;

function mR3NUM_SETKNOT(p1, p3) {
  return   DoA2(this.r3obj, 130025, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Fetch knot value by index
// Returns: Boolean, true if succeeded
// p1: Number, knot value
// p3: Integer, index

R3NUM_GETKNOT = 130026;

function mR3NUM_GETKNOT(p1, p3) {
  return   DoA2(this.r3obj, 130026, p1, R3TID_FLOAT, 0, p3, R3TID_INTEGER, 0);
}

// Description: Low level set point method. The point is given in object space.    * The method
//      doesn't generate R3MM_CHANGED nor call R3TTM_CHANGENIMATEDTAG.
// Returns: Boolean, true if succeeded
// p1: Integer, index
// p3: r3Vect4, point

R3NUM_SETPOINTLOCAL = 130027;

function mR3NUM_SETPOINTLOCAL(p1, p3) {
  return   DoA2(this.r3obj, 130027, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR4, 0);
}

// Description: Get point in object space
// Returns: Boolean, true if succeeded
// p1: Integer, index
// p3: r3Vect4, point

R3NUM_GETPOINTLOCAL = 130028;

function mR3NUM_GETPOINTLOCAL(p1, p3) {
  return   DoA2(this.r3obj, 130028, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR4, 0);
}

// Description: Class message: Test if R3CURVENODE *p1 is inside R3CURVENODE *p3. R3NUCM_PREPARESHRINK must be called
//      prior this operation.
// Returns: Boolean, true if is inside

R3NUCM_SHRINKISINSIDE = 130029;

function mR3NUCM_SHRINKISINSIDE() {
  return   DoA(this.r3obj, 130029, 0, R3TID_INTEGER, 0);
}

// Description: measure lenght of curve
// p3: Number, address of result value

R3NUM_MEASURELENGTH = 130030;

function mR3NUM_MEASURELENGTH(p3) {
  DoA(this.r3obj, 130030, p3, R3TID_FLOAT, 0);
}

// Description: Adjust points so that each curve segment is equally long. The operation sets parametrization
//      to uniform and usually changes curve shape slightly.

R3NUM_DISTRIBUTEEVENLY = 130031;

function mR3NUM_DISTRIBUTEEVENLY() {
  DoA(this.r3obj, 130031, 0, R3TID_INTEGER, 0);
}




R3NUA_Count = 130500;
function SetR3NUA_Count(value) {
  R3Set(this.r3obj, R3NUA_Count, value, R3TID_INTEGER, 0);
}

function GetR3NUA_Count() {
  return R3Get(this.r3obj, R3NUA_Count, R3TID_INTEGER, 0);
}

R3NUA_Order = 130501;
function SetR3NUA_Order(value) {
  R3Set(this.r3obj, R3NUA_Order, value, R3TID_INTEGER, 0);
}

function GetR3NUA_Order() {
  return R3Get(this.r3obj, R3NUA_Order, R3TID_INTEGER, 0);
}

R3NUA_Knots = 130502;
function SetR3NUA_Knots(value) {
  R3Set(this.r3obj, R3NUA_Knots, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUA_Knots() {
  return R3Get(this.r3obj, R3NUA_Knots, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUA_Points = 130503;
function SetR3NUA_Points(value) {
  R3Set(this.r3obj, R3NUA_Points, value, R3TID_OBJECT, 0);
}

function GetR3NUA_Points() {
  return R3ToJS(R3Get(this.r3obj, R3NUA_Points, R3TID_OBJECT, 0));
}

R3NUA_KnotCount = 130504;
function GetR3NUA_KnotCount() {
  return R3Get(this.r3obj, R3NUA_KnotCount, R3TID_INTEGER, 0);
}

R3NUA_Points3 = 130505;
function SetR3NUA_Points3(value) {
  R3Set(this.r3obj, R3NUA_Points3, value, R3TID_VECTOR, R3TNF_ARRAY);
}

function GetR3NUA_Points3() {
  return R3Get(this.r3obj, R3NUA_Points3, R3TID_VECTOR, R3TNF_ARRAY);
}

R3NUA_Closed = 130506;
function SetR3NUA_Closed(value) {
  R3Set(this.r3obj, R3NUA_Closed, value, R3TID_INTEGER, 0);
}

function GetR3NUA_Closed() {
  return R3Get(this.r3obj, R3NUA_Closed, R3TID_INTEGER, 0);
}

R3NUA_InParentsParamSpace = 130507;
function SetR3NUA_InParentsParamSpace(value) {
  R3Set(this.r3obj, R3NUA_InParentsParamSpace, value, R3TID_INTEGER, 0);
}

function GetR3NUA_InParentsParamSpace() {
  return R3Get(this.r3obj, R3NUA_InParentsParamSpace, R3TID_INTEGER, 0);
}

R3NUA_DefaultTool = 130509;
function SetR3NUA_DefaultTool(value) {
  R3Set(this.r3obj, R3NUA_DefaultTool, value, R3TID_INTEGER, 0);
}

function GetR3NUA_DefaultTool() {
  return R3Get(this.r3obj, R3NUA_DefaultTool, R3TID_INTEGER, 0);
}

R3NUA_Parametrization = 130510;
function SetR3NUA_Parametrization(value) {
  R3Set(this.r3obj, R3NUA_Parametrization, value, R3TID_INTEGER, 0);
}

function GetR3NUA_Parametrization() {
  return R3Get(this.r3obj, R3NUA_Parametrization, R3TID_INTEGER, 0);
}

R3NUA_Diameter1 = 130511;
function SetR3NUA_Diameter1(value) {
  R3Set(this.r3obj, R3NUA_Diameter1, value, R3TID_FLOAT, 0);
}

function GetR3NUA_Diameter1() {
  return R3Get(this.r3obj, R3NUA_Diameter1, R3TID_FLOAT, 0);
}

R3NUA_Diameter2 = 130512;
function SetR3NUA_Diameter2(value) {
  R3Set(this.r3obj, R3NUA_Diameter2, value, R3TID_FLOAT, 0);
}

function GetR3NUA_Diameter2() {
  return R3Get(this.r3obj, R3NUA_Diameter2, R3TID_FLOAT, 0);
}

R3NUA_Ends = 130513;
function SetR3NUA_Ends(value) {
  R3Set(this.r3obj, R3NUA_Ends, value, R3TID_INTEGER, 0);
}

function GetR3NUA_Ends() {
  return R3Get(this.r3obj, R3NUA_Ends, R3TID_INTEGER, 0);
}

R3NUA_ScanLineQuality = 130514;
function SetR3NUA_ScanLineQuality(value) {
  R3Set(this.r3obj, R3NUA_ScanLineQuality, value, R3TID_INTEGER, 0);
}

function GetR3NUA_ScanLineQuality() {
  return R3Get(this.r3obj, R3NUA_ScanLineQuality, R3TID_INTEGER, 0);
}

R3NUA_Min = 130515;
function SetR3NUA_Min(value) {
  R3Set(this.r3obj, R3NUA_Min, value, R3TID_FLOAT, 0);
}

function GetR3NUA_Min() {
  return R3Get(this.r3obj, R3NUA_Min, R3TID_FLOAT, 0);
}

R3NUA_Max = 130516;
function SetR3NUA_Max(value) {
  R3Set(this.r3obj, R3NUA_Max, value, R3TID_FLOAT, 0);
}

function GetR3NUA_Max() {
  return R3Get(this.r3obj, R3NUA_Max, R3TID_FLOAT, 0);
}

R3NUA_DiameterChannel = 130517;
function SetR3NUA_DiameterChannel(value) {
  R3Set(this.r3obj, R3NUA_DiameterChannel, value, R3TID_STRING, 0);
}

function GetR3NUA_DiameterChannel() {
  return R3Get(this.r3obj, R3NUA_DiameterChannel, R3TID_STRING, 0);
}

R3NUA_RenderRaytrace = 130518;
function SetR3NUA_RenderRaytrace(value) {
  R3Set(this.r3obj, R3NUA_RenderRaytrace, value, R3TID_BOOLEAN, 0);
}

function GetR3NUA_RenderRaytrace() {
  return R3Get(this.r3obj, R3NUA_RenderRaytrace, R3TID_BOOLEAN, 0);
}

R3NUA_RenderScanline = 130519;
function SetR3NUA_RenderScanline(value) {
  R3Set(this.r3obj, R3NUA_RenderScanline, value, R3TID_BOOLEAN, 0);
}

function GetR3NUA_RenderScanline() {
  return R3Get(this.r3obj, R3NUA_RenderScanline, R3TID_BOOLEAN, 0);
}

R3NUA_MaxDisplacement = 130520;
function SetR3NUA_MaxDisplacement(value) {
  R3Set(this.r3obj, R3NUA_MaxDisplacement, value, R3TID_FLOAT, 0);
}

function GetR3NUA_MaxDisplacement() {
  return R3Get(this.r3obj, R3NUA_MaxDisplacement, R3TID_FLOAT, 0);
}

R3NUA_RenderPostProc = 130521;
function SetR3NUA_RenderPostProc(value) {
  R3Set(this.r3obj, R3NUA_RenderPostProc, value, R3TID_BOOLEAN, 0);
}

function GetR3NUA_RenderPostProc() {
  return R3Get(this.r3obj, R3NUA_RenderPostProc, R3TID_BOOLEAN, 0);
}

var R3NUHT_CONTROLPOINT = 0;
var R3NUHT_KNOTPOINT = 1;
var R3NUT_MOVE = 0;
var R3NUT_WEIGHT = 1;
var R3NUT_INVERSEKINEMATICS = 2;
var R3NUE_PHANTOM = 0;
var R3NUE_MAXMULTIPLICITY = 1;
var R3NUMAXORDER = 6;


function r3Nurbs () {
   this.base = r3God;
   if(arguments.length) {
      this.base(R3CLID_NURBS, arguments);
   }
   // Methods
   this.CONCATENATE=mR3NUM_CONCATENATE;
   this.SHARPEN=mR3NUM_SHARPEN;
   this.BREAK=mR3NUM_BREAK;
   this.INSERTKNOT=mR3NUM_INSERTKNOT;
   this.TOBEZIER=mR3NUM_TOBEZIER;
   this.ELEVATEDEGREE=mR3NUM_ELEVATEDEGREE;
   this.CUTHEAD=mR3NUM_CUTHEAD;
   this.CUTTAIL=mR3NUM_CUTTAIL;
   this.SWAPDIRECTION=mR3NUM_SWAPDIRECTION;
   this.CHANGEWEIGHTS=mR3NUM_CHANGEWEIGHTS;
   this.CHANGEORDER=mR3NUM_CHANGEORDER;
   this.INSERTKNOTARRAY=mR3NUM_INSERTKNOTARRAY;
   this.INTERPOLATE=mR3NUM_INTERPOLATE;
   this.UNIFY=mR3NUCM_UNIFY;
   this.OPEN=mR3NUM_OPEN;
   this.SETSTART=mR3NUM_SETSTART;
   this.PARALLELCURVE=mR3NUM_PARALLELCURVE;
   this.ADDTOSHRINK=mR3NUM_ADDTOSHRINK;
   this.PREPARESHRINK=mR3NUCM_PREPARESHRINK;
   this.SHRINK=mR3NUCM_SHRINK;
   this.FREESHRINK=mR3NUCM_FREESHRINK;
   this.INSERTCTRLPOINT=mR3NUM_INSERTCTRLPOINT;
   this.SETPOINT4=mR3NUM_SETPOINT4;
   this.GETPOINT4=mR3NUM_GETPOINT4;
   this.SETKNOT=mR3NUM_SETKNOT;
   this.GETKNOT=mR3NUM_GETKNOT;
   this.SETPOINTLOCAL=mR3NUM_SETPOINTLOCAL;
   this.GETPOINTLOCAL=mR3NUM_GETPOINTLOCAL;
   this.SHRINKISINSIDE=mR3NUCM_SHRINKISINSIDE;
   this.MEASURELENGTH=mR3NUM_MEASURELENGTH;
   this.DISTRIBUTEEVENLY=mR3NUM_DISTRIBUTEEVENLY;

   // Attributes
   this.GetCount=GetR3NUA_Count;
   this.SetCount=SetR3NUA_Count;
   this.GetOrder=GetR3NUA_Order;
   this.SetOrder=SetR3NUA_Order;
   this.GetKnots=GetR3NUA_Knots;
   this.SetKnots=SetR3NUA_Knots;
   this.GetPoints=GetR3NUA_Points;
   this.SetPoints=SetR3NUA_Points;
   this.GetKnotCount=GetR3NUA_KnotCount;
   this.GetPoints3=GetR3NUA_Points3;
   this.SetPoints3=SetR3NUA_Points3;
   this.GetClosed=GetR3NUA_Closed;
   this.SetClosed=SetR3NUA_Closed;
   this.GetInParentsParamSpace=GetR3NUA_InParentsParamSpace;
   this.SetInParentsParamSpace=SetR3NUA_InParentsParamSpace;
   this.GetDefaultTool=GetR3NUA_DefaultTool;
   this.SetDefaultTool=SetR3NUA_DefaultTool;
   this.GetParametrization=GetR3NUA_Parametrization;
   this.SetParametrization=SetR3NUA_Parametrization;
   this.GetDiameter1=GetR3NUA_Diameter1;
   this.SetDiameter1=SetR3NUA_Diameter1;
   this.GetDiameter2=GetR3NUA_Diameter2;
   this.SetDiameter2=SetR3NUA_Diameter2;
   this.GetEnds=GetR3NUA_Ends;
   this.SetEnds=SetR3NUA_Ends;
   this.GetScanLineQuality=GetR3NUA_ScanLineQuality;
   this.SetScanLineQuality=SetR3NUA_ScanLineQuality;
   this.GetMin=GetR3NUA_Min;
   this.SetMin=SetR3NUA_Min;
   this.GetMax=GetR3NUA_Max;
   this.SetMax=SetR3NUA_Max;
   this.GetDiameterChannel=GetR3NUA_DiameterChannel;
   this.SetDiameterChannel=SetR3NUA_DiameterChannel;
   this.GetRenderRaytrace=GetR3NUA_RenderRaytrace;
   this.SetRenderRaytrace=SetR3NUA_RenderRaytrace;
   this.GetRenderScanline=GetR3NUA_RenderScanline;
   this.SetRenderScanline=SetR3NUA_RenderScanline;
   this.GetMaxDisplacement=GetR3NUA_MaxDisplacement;
   this.SetMaxDisplacement=SetR3NUA_MaxDisplacement;
   this.GetRenderPostProc=GetR3NUA_RenderPostProc;
   this.SetRenderPostProc=SetR3NUA_RenderPostProc;
}

r3Nurbs.prototype=new r3Primitive;
// r3nurbs.h_H